package Lambda;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * 函数式接口：当一个接口当中，只有一个抽象方法的时候
 * @FunctionalInterface注解：帮我们判断是否为函数式接口
 */
@FunctionalInterface
interface NoParameterNoReturn{
    //抽象方法，一定要有一个类来实现这个方法才能调用这个方法，但是这里没有
    void test();
}

//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}


//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}


public class Test {
    public static void main(String[] args) {
        HashMap<String,Integer> map = new HashMap<>();
        map.put("abc",3);
        map.put("aer",2);
        map.put("bas",0);
        map.put("acc",1);

        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key"+s+"value"+integer);
            }
        });

        map.forEach((k,v)-> System.out.println("key "+k+" value "+v));
    }
    public static void main7(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("aaa");
        list.add("hhh");

//          1.
//        list.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        //2.
        list.forEach(s-> System.out.println(s));

        //1.
//        list.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareTo(o2);
//            }
//        });

        //2.
        list.sort((o1,o2)->o1.compareTo(o2));
        list.forEach(s-> System.out.println(s));

    }

    public static void main6(String[] args) {
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
    }

    PriorityQueue<Integer> maxHeap1 = new PriorityQueue<>((x,y)->{return x.compareTo(y);});
    PriorityQueue<Integer> maxHeap2 = new PriorityQueue<>((x,y)->x.compareTo(y));


    public static void main5(String[] args) {
        int a = 10;
        //a = 100;//Lambda变得的捕获，捕获的变量是不能被修改过的饿，或者是一个常量
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                //此时驳货的变量，一定要是没有被修改过的变量，或者是一个常量
                System.out.println("a = +" + a);
            }
        };

        noParameterNoReturn.test();
    }

    public static void main4(String[] args) {
        //MoreParameterReturn moreParameterReturn = (x,y)->{return x*y;};
        MoreParameterReturn moreParameterReturn = (x,y)->x*y;
        int ret = moreParameterReturn.test(10,10);
        System.out.println(ret);
    }
    public static void main3(String[] args) {
        //NoParameterReturn noParameterReturn = ()->{return 1;};
        NoParameterReturn noParameterReturn = ()->10;

        int ret = noParameterReturn.test();
        System.out.println(ret);

        OneParameterReturn oneParameterReturn = x-> x*2;
        int ret1 = oneParameterReturn.test(10);
        System.out.println(ret1);
    }

    public static void main2(String[] args) {
        //只有一个参数可以省略括号，只有一条语句可以省略花括号
        OneParameterNoReturn oneParameterNoReturn = (x)->{
            System.out.println(x);
        };
        oneParameterNoReturn.test(10);
        System.out.println("============");

        MoreParameterNoReturn moreParameterNoReturn = (x,y)->{
            System.out.println(x+y);
        };
        moreParameterNoReturn.test(10,20);

    }

    public static void main1(String[] args) {
        //匿名内部内来调用这个test方法(没有Lambda表达式是这样写)
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            //重写不带参数的构造方法
            public void test() {
                System.out.println("1234");
            }
        };

        noParameterNoReturn.test();

        //Lambda表达式的写法
        //代表匿名内部内实现了这个接口同时重写了test这个方法
        //()：参数列表，后面接着的是方法体
        NoParameterNoReturn noParameterNoReturn2 = ()-> System.out.println("1234");

        noParameterNoReturn2.test();
    }


}
